home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / scheme / schmlbrr / schem_lb.lha / unsupported / CScheme / sequence.scm < prev    next >
Encoding:
Text File  |  1991-08-05  |  17.7 KB  |  560 lines
  1. ;;; -*- Base: 10; Mode: Scheme; Syntax: MIT Scheme; Package: USER -*-
  2. ;;
  3. ;; SEQUENCE.SCM
  4. ;;
  5. ;; July 7, 1991
  6. ;; Minghsun Liu
  7. ;;
  8. ;; Some definitions related to CommonLisp datatyp SEQUENCE.
  9. ;;
  10. ;;
  11. ;; The following(s) is(are) defined:
  12. ;;
  13. ;; (NSUBSTITUTE-IF NEWITEM PRED SEQUENCE . KEYWORDS)
  14. ;; (NSUBSTITUTE-IF-NOT NEWITEM PRED SEQUENCE . KEYWORDS)
  15. ;; :TEST
  16. ;; :TEST-NOT
  17. ;; :KEY
  18. ;; :FROM-END
  19. ;; :START
  20. ;; :END
  21. ;; :START1
  22. ;; :START2
  23. ;; :END1
  24. ;; :END2
  25. ;; (FIND ITEM SEQ . KEYWORDS) 
  26. ;; (SEARCH SEQ1 SEQ2 . KEYWORDS)
  27. ;; (CL-SORT SEQ PRED . KEYWORD)
  28. ;; (POSITION ITEM SEQ . KEYWORDS)
  29. ;; (ELT SEQ INDEX)
  30. ;; (COUNT ITEM SEQ . KEYWORDS)
  31. ;; (CONCATENATE RESULT-TYPE . SEQUENCES)
  32. ;; (COUNT-IF TEST SEQ . KEYWORDS)
  33. ;; (FILL SEQ ITEM . KEYWORDS)
  34. ;;
  35. (declare (usual-integrations))
  36.  
  37. ;;
  38. ;; (NSUBSTITUTE-IF NEWITEM PRED SEQUENCE . KEYWORDS)
  39. ;;
  40. ;; change a sequence by substituting NEWITEM for old ones that satisfy
  41. ;; the PRED test.  A sequence is either of type list, vector, string.
  42. ;;
  43. ;; P.S. For now, none of the keyword is implemented.
  44. ;;
  45. (define (nsubstitute-if newitem pred sequen #!rest keywords)
  46.   (if (not (null? keywords))
  47.       ;; just to be sure....
  48.       (error "NSUBSTITUTE-IF: Keywords not supported for now.")
  49.       (let ((temp '()))
  50.     (define (nsubstitute-if-aux cur-sequence)
  51.       (cond ((null? cur-sequence) 
  52.          (if (array? sequen)
  53.              temp
  54.              sequen))
  55.         ((pred (car cur-sequence))
  56.          (set-car! cur-sequence newitem)
  57.          (nsubstitute-if-aux (cdr cur-sequence)))
  58.         (else (nsubstitute-if-aux 
  59.                (cdr cur-sequence)))))
  60.     (cond ((array? sequen)
  61.            (set! temp (sequen 'just-the-array-maam))
  62.            (if (and (not (vector? temp)) (null? (sequen 'array-dimensions)))
  63.            (if (pred temp)
  64.                (sequen 'change-myself newitem))
  65.            (begin
  66.              (set! temp (vector->list temp))
  67.              (sequen 'change-myself (list->vector (nsubstitute-if-aux temp))))))
  68.           ((list? sequen)
  69.            (nsubstitute-if-aux sequen))
  70.           ((vector? sequen)
  71.            ;; this is hackish and inconsistent but is due to the
  72.            ;; way vectors are implemented in MIT Scheme.
  73.            (set! sequen (vector->list sequen))
  74.            (list->vector (nsubstitute-if-aux sequen)))
  75.           ((string? sequen)
  76.            (set! sequen (string->list sequen))
  77.            (string->list (nsubstitue-if-aux sequen)))
  78.           (else (error "NSUBSTITUTE-IF: Not a sequence")
  79.             (write-line cur-sequence))))))
  80.  
  81. ;;
  82. ;; (NSUBSTITUTE-IF-NOT NEWITEM PRED SEQUEN . KEYWORDS)
  83. ;;
  84. ;; change a sequence by substituting NEWITEM for old ones that do not
  85. ;; satisfy the PRED test.
  86. ;;
  87. ;; P.S. This is written in terms of NSUBSTITUE-IF.
  88. ;;
  89. (define (nsubstitute-if-not newitem pred sequen #!rest keywords)
  90.   (if (not (null? keywords))
  91.       (error "NSUBSTITUTE-IF-NOT: Keywords not supported for now." keywords)
  92.       (nsubstitute-if 
  93.        newitem 
  94.        (lambda (obj) (not (pred obj)))
  95.        sequen)))
  96.  
  97. ;;
  98. ;; :TEST
  99. ;; :TEST-NOT
  100. ;; :KEY
  101. ;; :FROM-END
  102. ;; :START
  103. ;; :END
  104. ;; :START1
  105. ;; :START2
  106. ;; :END1
  107. ;; :END2
  108. ;;
  109. ;; are all keywords used by FIND, etc. and should be constant.
  110. ;;
  111. (define :test ':test)
  112. (define :test-not ':test-not)
  113. (define :key ':key)
  114. (define :from-end ':from-end)
  115. (define :start ':start)
  116. (define :end ':end)
  117. (define :start1 ':start1)
  118. (define :start2 ':start2)
  119. (define :end1 ':end1)
  120. (define :end2 ':end2)
  121.  
  122. ;;
  123. ;; (FIND ITEM SEQ . KEYWORDS)
  124. ;;
  125. ;; returns an element within a sequence that satisfies a test.
  126. ;;
  127. ;; P.S. For now the keyfnc defaults to the identity and perhaps it
  128. ;; should be optimized somehow. 
  129. ;;
  130. (define (find item seq #!rest keywords)
  131.   (let ((test-pos? #t)
  132.     (pred eqv?)
  133.     (temp '())
  134.     (keyfnc (lambda (obj) obj))
  135.     (fe #f)
  136.     (sn 0)
  137.     (en '()))
  138.     (define (process-keywords unprocessed-kw)
  139.       (if (null? unprocessed-kw) 
  140.       'done!
  141.       (case (car unprocessed-kw)
  142.         (:test-not (set! test-pos? #f)
  143.                (set! pred (cadr unprocessed-kw))
  144.                (process-keywords (cddr unprocessed-kw)))
  145.         (:test (set! pred (cadr unprocessed-kw))
  146.            (process-keywords (cddr unprocessed-kw)))
  147.         (:key (if (cadr unprocessed-kw)
  148.               (set! keyfnc (cadr unprocessed-kw)))
  149.           (process-keywords (cddr unprocessed-kw)))
  150.         (:from-end (set! fe (cadr unprocessed-kw))
  151.                (process-keywords (cddr unprocessed-kw)))
  152.         (:start (set! sn (cadr unprocessed-kw))
  153.             (process-keywords (cddr unprocessed-kw)))
  154.         (:end (set! en (cadr unprocessed-kw))
  155.              (process-keywords (cddr unprocessed-kw)))
  156.         (else (write-line unprocessed-kw)
  157.           (error "FIND: Invalid keyword")))))
  158.     (define (find-aux sequ)
  159.       (cond ((null? sequ) '())
  160.         ((eq? test-pos? 
  161.           (pred (keyfnc (car sequ)) item)) (car sequ))
  162.         (else (find-aux (cdr sequ)))))
  163.     (define (get-subsequence)
  164.       (if en
  165.       (sublist seq sn en)
  166.       (sublist seq sn (length seq))))
  167.     ;; The approach taken here is to convert everything into list
  168.     ;; since its probably the most general structure that can
  169.     ;; accomodate all possible data.
  170.     (process-keywords keywords)
  171.     (when fe (set! seq (reverse seq)))
  172.     (set! temp (seq 'just-the-array-maam))
  173.     (cond ((array? seq) (if (and (not (vector? temp))
  174.                  (null? (seq 'array-dimensions)))
  175.                 (set! seq (list temp))
  176.                 (set! seq (vector->list temp)))
  177.             (find-aux (get-subsequence)))
  178.       ((vector? seq) (set! seq (vector->list seq))
  179.              (find-aux (get-subsequence)))
  180.       ((string? seq) (set! seq (string->list seq))
  181.              (set! item (name->char item))
  182.              (let ((result 
  183.                 (find-aux (get-subsequence))))
  184.                (if result
  185.                    (char->name result)
  186.                    '())))
  187.       ((list? seq) (find-aux (get-subsequence)))
  188.       (else (error "FIND: Not a sequence" seq)))))
  189.        
  190. ;;
  191. ;; (SEARCH SEQ1 SEQ2 . KEYWORDS)
  192. ;;
  193. ;; search one sequence for another on contained in it.
  194. ;;
  195. (define (search seq1 seq2 #!rest keywords)
  196.   (let ((test-pos? #t)
  197.         (pred eqv?)
  198.         (keyfnc (lambda (obj) obj))
  199.         (fe #f)
  200.     (temp1 '())
  201.     (temp2 '())
  202.         (sn1 0)
  203.         (en1 '())
  204.     (sn2 0)
  205.     (en2 '())
  206.     (ind -1)
  207.     (temp-end 0))
  208.     (define (process-keywords unprocessed-kw)
  209.       (if (null? unprocessed-kw)
  210.       'done
  211.       (case (car unprocessed-kw)
  212.         (:test-not (set! test-pos? #f)
  213.                        (set! pred (cadr unprocessed-kw))
  214.                        (process-keywords (cddr unprocessed-kw)))
  215.             (:test (set! pred (cadr unprocessed-kw))
  216.                    (process-keywords (cddr unprocessed-kw)))
  217.             (:key (if (cadr unprocessed-kw)
  218.                       (set! keyfnc (cadr unprocessed-kw)))
  219.                   (process-keywords (cddr unprocessed-kw)))
  220.             (:from-end (set! fe (cadr unprocessed-kw))
  221.                        (process-keywords (cddr unprocessed-kw)))
  222.             (:start1 (set! sn1 (cadr unprocessed-kw))
  223.              (process-keywords (cddr unprocessed-kw)))
  224.             (:end1 (set! en1 (cadr unprocessed-kw))
  225.            (process-keywords (cddr unprocessed-kw)))
  226.         (:start2 (set! sn2 (cadr unprocessed-kw))
  227.              (process-keywords (cddr unprocessed-kw)))
  228.         (:end2 (set! en2 (cadr unprocessed-kw))
  229.            (process-keywords (cddr unprocessed-kw)))
  230.         (else (write-line unprocessed-kw)
  231.                   (error "SEARCH: Invalid keyword")))))
  232.     (define (search-aux-1 sequ1-sequ2)
  233.       (let ((sequ1 (car sequ1-sequ2))
  234.         (sequ2 (cadr sequ1-sequ2)))
  235.     (set! temp-end (length sequ2))
  236.     (set! ind (+ ind sn2))
  237.     (search-aux-2 sequ1 sequ2)))
  238.     (define (search-aux-2 s1 s2)
  239.       (cond ((not (null? s2))
  240.          (set! ind (1+ ind))
  241.          (search-aux-3 s1 (sublist s2 ind temp-end)))
  242.         (else #f)))
  243.     (define (search-aux-3 l1 l2)  ;; can't think of a better name;
  244.                                   ;; sequel syndrome.
  245.       (cond ((null? l1) 
  246.          ind)
  247.         ((null? l2)
  248.          '())
  249.         ((eq? test-pos? 
  250.           (pred (keyfnc (car l1)) 
  251.             (keyfnc (car l2))))
  252.          (search-aux-3 (cdr l1) (cdr l2)))
  253.         (else 
  254.          (search-aux-2 seq1 seq2))))
  255.     (define (proc-result result)
  256.       (if (and fe result)
  257.       (set! result (- (length seq2) (+ result (length seq1)))))
  258.       (if (and (not (zero? sn2)) result)
  259.       (set! result (+ result sn2)))
  260.       result)
  261.     (define (get-subsequence)
  262.       (if fe
  263.       (begin
  264.         (set! seq2 (reverse seq2))
  265.         (set! seq1 (reverse seq1))))
  266.       (list (sublist seq1 sn1 (if en1 en1 (length seq1)))
  267.         (sublist seq2 sn2 (if en2 en2 (length seq2)))))
  268.     ;; The method implemented here follows the same line of thinking
  269.     ;; as that described in FIND.
  270.     (process-keywords keywords)
  271.     (cond ((and (array? seq1) (array? seq2))
  272.        (set! temp1 (seq1 'just-the-array-maam))
  273.        (set! temp2 (seq2 'just-the-array-maam))
  274.        (if (null? (seq1 'array-dimensions))
  275.            (set! temp1 (vector temp1)))
  276.        (if (null? (seq2 'array-dimensions))
  277.            (set! temp2 (vecotr temp2)))
  278.        (set! seq1 (vector->list temp1))
  279.        (set! seq2 (vector->list temp2))
  280.        (proc-result (search-aux-1 (get-subsequence))))
  281.       ((and (vector? seq1) (vector? seq2))
  282.        (set! seq1 (vector->list seq1))
  283.        (set! seq2 (vector->list seq2))
  284.        (proc-result (search-aux-1 (get-subsequence))))
  285.       ((and (string? seq1) (string? seq2))
  286.        (set! seq1 (string->list seq1))
  287.        (set! seq2 (string->list seq2))
  288.        (set! item (name->char item))
  289.        (proc-result (search-aux-1 (get-subsequence))))
  290.       ((and (list? seq1) (list? seq2))
  291.        (proc-result (search-aux-1 (get-subsequence))))
  292.       (else (error "SEARCH: Not sequences" seq1 seq2)))))
  293.       
  294. ;;
  295. ;; (CL-SORT SEQ PRED . KEYWORD)
  296. ;;
  297. ;; sort a sequence according to some criterion.  (One note though, this
  298. ;; is not guranteed to be destructive.)
  299. ;; 
  300. (define (cl-sort seq pred #!rest keyword)
  301.   (let ((keyfnc '()))
  302.     (define (process-keyword)
  303.       (if (not (null? keyword))
  304.       (if (eq? (car keyword) :key)
  305.           (set! keyfnc (cadr keyword))
  306.           (error "CL-SORT: unknown keyword" keyword))))
  307.     (define (get-predicate)
  308.       (if keyfnc
  309.       (lambda (x y)
  310.         (let ((a (keyfnc x))
  311.           (b (keyfnc y)))
  312.           (or (pred a b)
  313.           (equal? a b))))
  314.       (lambda (x y)
  315.         (or (pred a b) (equal? a b)))))
  316.     (process-keyword)
  317.     (cond ((array? seq)
  318.        (if (null? (seq 'array-dimensions))
  319.            (seq 'just-the-array-maam)
  320.            (seq 'change-myself (sort (just-the-array-maam seq) (get-predicate)))))
  321.       ((string? seq)
  322.        (set! seq (string->list seq))
  323.        (list->string (sort seq (get-predicate))))
  324.       ((vector? seq)
  325.        (sort seq (get-predicate)))
  326.       ((list? seq)
  327.        (sort seq (get-predicate)))
  328.       (else (error "CL-SORT: Not a sequence" seq)))))
  329.  
  330.  
  331. ;;
  332. ;; (POSITION ITEM SEQ . KEYWORDS)
  333. ;;
  334. ;; locates an element in a sequence and returns the position of ITEM.
  335. ;;
  336. (define (position item seq #!rest keywords)
  337.   (let ((test-pos? #t)
  338.         (pred eqv?)
  339.         (keyfnc (lambda (obj) obj))
  340.         (fe #f)
  341.         (sn 0)
  342.     (post-ind 0)
  343.         (en '()))
  344.     (define (process-keywords unprocessed-kw)
  345.       (if (null? unprocessed-kw)
  346.           'done!
  347.           (case (car unprocessed-kw)
  348.             (:test-not (set! test-pos? #f)
  349.                        (set! pred (cadr unprocessed-kw))
  350.                        (process-keywords (cddr unprocessed-kw)))
  351.             (:test (set! pred (cadr unprocessed-kw))
  352.                    (process-keywords (cddr unprocessed-kw)))
  353.             (:key (if (cadr unprocessed-kw)
  354.                       (set! keyfnc (cadr unprocessed-kw)))
  355.                   (process-keywords (cddr unprocessed-kw)))
  356.             (:from-end (set! fe (cadr unprocessed-kw))
  357.                        (process-keywords (cddr unprocessed-kw)))
  358.             (:start (set! sn (cadr unprocessed-kw))
  359.             (set! post-ind sn)
  360.                     (process-keywords (cddr unprocessed-kw)))
  361.             (:end (set! en (cadr unprocessed-kw))
  362.           (process-keywords (cddr unprocessed-kw)))
  363.             (else (write-line unprocessed-kw)
  364.                   (error "POSITION: Invalid keyword")))))
  365.     (define (get-subsequence)
  366.       (if en
  367.           (sublist seq sn en)
  368.           (sublist seq sn (length seq))))
  369.     (define (post-aux sequ)
  370.       (cond ((null? sequ) '())
  371.         ((eq? test-pos? (pred (keyfnc (car sequ)) item)) 
  372.          post-ind)
  373.         (else
  374.          (set! post-ind (1+ post-ind))
  375.          (post-aux (cdr sequ)))))
  376.     (define (proc-res result)
  377.       (if (and result fe)
  378.       (set! result (- (length seq) (1+ result))))
  379.       result)
  380.     (process-keywords keywords)
  381.     (when fe (set! seq (reverse seq)))
  382.     (cond ((array? seq) (if (null? (seq 'array-dimensions))
  383.                 (set! seq (list (seq 'just-the-array-maam)))
  384.                 (set! seq (vector->list (just-the-array-maam
  385.                              seq))))
  386.             (proc-res (post-aux (get-subsequence))))
  387.       ((vector? seq) (set! seq (vector->list seq))
  388.                          (proc-res (post-aux (get-subsequence))))
  389.           ((string? seq) (set! seq (string->list seq))
  390.                          (set! item (name->char item))
  391.              (proc-res (post-aux (get-subsequence))))
  392.       ((list? seq) (proc-res (post-aux (get-subsequence))))
  393.           (else (error "POSITION: Not a sequence" seq)))))
  394.  
  395.  
  396. ;;
  397. ;; (ELT SEQ INDEX)
  398. ;;        
  399. ;; return the element of a sequence at a given index.
  400. ;;
  401. (define (elt seq index)
  402.   (cond ((array? seq) (seq 'array-ref index))
  403.     ((vector? seq) (vector-ref seq index))
  404.     ((list? seq) (list-ref seq index))
  405.     ((string? seq) (string-ref seq index))
  406.     (else (error "ELT: Not a sequence" seq))))
  407.  
  408.  
  409. ;;
  410. ;; (COUNT ITEM SEQ . KEYWORDS)
  411. ;;
  412. ;; count the numer of ITEM in SEQ that satisfy a test.
  413. ;;
  414. (define (count item seq #!rest keywords)
  415.   (let ((temp '())
  416.     (cur-count 0)
  417.     (test-pos? #t)
  418.         (pred eqv?)
  419.         (keyfnc (lambda (obj) obj))
  420.         (fe #f)
  421.         (sn 0)
  422.         (en '()))
  423.     (define (process-keywords unprocessed-kw)
  424.       (if (null? unprocessed-kw)
  425.           'done!
  426.           (case (car unprocessed-kw)
  427.             (:test-not (set! test-pos? #f)
  428.                        (set! pred (cadr unprocessed-kw))
  429.                        (process-keywords (cddr unprocessed-kw)))
  430.             (:test (set! pred (cadr unprocessed-kw))
  431.                    (process-keywords (cddr unprocessed-kw)))
  432.             (:key (if (cadr unprocessed-kw)
  433.                       (set! keyfnc (cadr unprocessed-kw)))
  434.                   (process-keywords (cddr unprocessed-kw)))
  435.             (:from-end (set! fe (cadr unprocessed-kw))
  436.                        (process-keywords (cddr unprocessed-kw)))
  437.             (:start (set! sn (cadr unprocessed-kw))
  438.                     (process-keywords (cddr unprocessed-kw)))
  439.             (:end (set! en (cadr unprocessed-kw))
  440.                      (process-keywords (cddr unprocessed-kw)))
  441.             (else (write-line unprocessed-kw)
  442.                   (error "COUNT: Invalid keyword")))))
  443.     (define (count-aux sequ)
  444.       (cond ((null? sequ) cur-count)
  445.         ((eq? test-pos?
  446.           (pred (keyfnc (car sequ)) item))
  447.          (set! cur-count (1+ cur-count))
  448.          (count-aux (cdr sequ)))
  449.         (else (count-aux (cdr sequ)))))
  450.     (define (get-subsequence)
  451.       (if en
  452.       (sublist seq sn en)
  453.       (sublist seq sn (length seq))))
  454.     ;; The approach taken here is to convert everything into list
  455.     ;; since its probably the most general structure that can
  456.     ;; accomodate all possible data.
  457.     (process-keywords keywords)
  458.     (when fe (set! seq (reverse seq)))
  459.     (cond ((array? seq) (set! temp (seq 'array-dimensions)) 
  460.             (set! seq (just-the-array-maam seq))
  461.             (if (null? temp)
  462.                 (set! seq (list seq))
  463.                 (set! seq (vector->list seq)))
  464.             (count-aux (get-subsequence)))
  465.       ((vector? seq) (set! seq (vector->list seq))
  466.                          (count-aux (get-subsequence)))
  467.           ((string? seq) (set! seq (string->list seq))
  468.                          (set! item (name->char item))
  469.              (count-aux (get-subsequence)))
  470.       ((list? seq) (count-aux (get-subsequence)))
  471.           (else (error "COUNT: Not a sequence" seq)))))
  472.  
  473.  
  474. ;;
  475. ;; (CONCATENATE RESULT-TPYE . SEQUENCES)
  476. ;;
  477. ;; join several sequences into one.
  478. ;;
  479. (define (concatenate result-type #!rest sequences)
  480.   (define (transform-all seq)
  481.     (cond ((list? seq) seq)
  482.       ((array? seq) (vector->list (seq 'just-the-array-maam)))
  483.       ((vector? seq) (vector->list seq))
  484.       ((string? seq) (string->list seq))
  485.       (else "CONCATENATE: not a sequence" seq)))
  486.   (let ((res-list
  487.      (apply append (map transform-all sequences))))
  488.     (case result-type
  489.       ((string) (list->string res-list))
  490.       ((vector) (write-line "Warning: CONCATENATE")
  491.         (make-array (list (length res-list)) :initial-contents res-list))
  492.       ((list) res-list)
  493.       (else (error "CONCATENATE: unkown result-type" result-type)))))
  494.  
  495.  
  496. ;;
  497. ;; (COUNT-IF TEST SEQ . KEYWORDS)
  498. ;;
  499. ;; count the number of elements which satisfy a test in a sequence.
  500. ;;
  501. (defmacro (count-if test seq #!rest keywords)
  502.   (let ((key-exist? (memq ':key keywords)))
  503.     (if key-exist?
  504.     `(count #t 
  505.         ,seq 
  506.         :key (lambda (elem) (,test (,(cadr key-exist?) elem)))
  507.         ,@(delete ':key (delete (cadr key-exist?) keywords)))
  508.     `(count #t
  509.         ,seq
  510.         :key (lambda (elem) (,test elem))
  511.         ,@keywords))))
  512.  
  513.  
  514. ;;
  515. ;; (FILL SEQ ITEM . KEYWORDS)
  516. ;;
  517. ;; replaces items in a sequence with a given item.
  518. ;;
  519. (define (fill seq item #!rest keywords)
  520.   (let ((temp '())
  521.     (sn 0)
  522.     (en '()))
  523.     (define (process-keywords unprocessed-kw)
  524.       (if (null? unprocessed-kw)
  525.           'done!
  526.           (case (car unprocessed-kw)
  527.             (:start (set! sn (cadr unprocessed-kw))
  528.                     (process-keywords (cddr unprocessed-kw)))
  529.             (:end (set! en (cadr unprocessed-kw))
  530.           (process-keywords (cddr unprocessed-kw)))
  531.             (else (write-line unprocessed-kw)
  532.                   (error "FILL: Invalid keyword")))))
  533.     (define (fill-aux cur-list)
  534.       (if (null? cur-list)
  535.       'done
  536.       (begin
  537.         (set-car! cur-list item)
  538.         (fill-aux (cdr cur-list)))))
  539.     (define (get-subsequence sequ)
  540.       (if en
  541.           (sublist sequ sn en)
  542.           (sublist sequ sn (length sequ))))
  543.     (process-keywords keywords)
  544.     (cond ((array? seq)
  545.        (set! temp (seq 'just-the-array-maam))
  546.        (if (null? (seq 'array-dimensions))
  547.            (set! temp (vector temp)))
  548.        (set! temp (vector->list temp))
  549.        (seq 'change-myself (list->vector (fill-aux (get-subsequence temp)))))
  550.       ((vector? seq)
  551.        (list->vecotr (fill-aux (vector->list (get-subsequence seq)))))
  552.       ((string? seq)
  553.        (list->string (fill-aux (string->list (get-subsequence seq)))))
  554.       ((list? seq)
  555.        (fill-aux (get-subsequence seq)))
  556.       (else (error "FILL: Not a sequence" seq)))))
  557.  
  558.     
  559.  
  560.